package main

import (
	"fmt"
	"strconv"
)

// ft 结构体用于模拟某种功能表（Function Table, FT）的设计
type ft struct {
    // jack 包含 27 个通道，用于与其他组件进行通信。每个通道可以传输 pulse 类型的数据。
    jack [27]chan pulse

    // inff1 和 inff2 是两个布尔数组，各自包含 11 个元素。它们可能用于存储状态标志或控制信息。
    inff1 [11]bool
    inff2 [11]bool

    // opsw 是操作开关数组，包含 11 个整数，用于控制不同的操作模式或设置。
    opsw [11]int

    // rptsw 是重复开关数组，与 opsw 类似，但专门用于控制重复操作或循环。
    rptsw [11]int

    // argsw 是参数开关数组，同样有 11 个元素，用于配置特定参数或条件。
    argsw [11]int

    // pm1 和 pm2 是两个整数变量，表示不同的参数模式或配置。
    pm1 int
    pm2 int

    // cons 是控制信号数组，包含 8 个整数，用于存储控制信号的值。
    cons [8]int

    // del 是延迟数组，包含 8 个整数，用于表示时间延迟或等待周期。
    del [8]int

    // sub 是减法数组，包含 12 个整数，用于执行减法运算或存储减法结果。
    sub [12]int

    // tab 是一个二维整型数组，大小为 104x14，用于存储大量的数据或函数查找表。
    tab [104][14]int

    // arg 是当前参数，单个整数，用于存储当前正在处理的参数值。
    arg int

    // ring 是环状态，单个整数，用于表示某种循环或状态机的状态。
    ring int

    // add 和 subtr 是布尔变量，分别表示是否执行加法和减法操作。
    add bool
    subtr bool

    // argsetup 是布尔变量，表示是否已经设置了参数。
    argsetup bool

    // gateh42 和 gatee42 是布尔变量，可能用于表示某些门控信号的状态。
    gateh42 bool
    gatee42 bool

    // update 是一个整数类型的通道，用于通知更新事件。
    update chan int

    // resp 是一个整数类型的通道，用于响应请求或事件。
    resp chan int

    // whichrp 是布尔变量，可能用于标记是否需要重复某些操作。
    whichrp bool

    // px4119 是布尔变量，可能用于表示某个特定条件或状态。
    px4119 bool
}

var ftable [3]ft

// 该函数用于返回指定单元的状态字符串，包括状态标志、参数值、环状态以及加法和减法操作的标志
func ftstat(unit int) (s string) {
    // 遍历 inff2 数组，将布尔值转换为 "1" 或 "0" 并拼接成字符串
    for i := 0; i < 11; i++ {
        if ftable[unit].inff2[i] {
            s += "1"
        } else {
            s += "0"
        }
    }

    // 添加当前参数（arg）和环状态（ring）到状态字符串中
    s += fmt.Sprintf(" %d %d", ftable[unit].arg, ftable[unit].ring)

    // 根据是否执行加法操作添加 "1" 或 "0" 到状态字符串中
    if ftable[unit].add {
        s += " 1"
    } else {
        s += " 0"
    }

    // 根据是否执行减法操作添加 "1" 或 "0" 到状态字符串中
    if ftable[unit].subtr {
        s += " 1"
    } else {
        s += " 0"
    }

    // 根据是否设置了参数添加 "1" 或 "0" 到状态字符串中
    if ftable[unit].argsetup {
        s += " 1"
    } else {
        s += " 0"
    }

    return
}

// 该函数用于重置指定单元的状态到默认值，清除所有通道、状态标志和其他字段
func ftreset(unit int) {
    f := &ftable[unit]

    // 清除所有的通道
    for i := 0; i < 27; i++ {
        f.jack[i] = nil
    }

    // 清除所有状态标志和开关设置
    for i := 0; i < 11; i++ {
        f.inff1[i] = false
        f.inff2[i] = false
        f.opsw[i] = 0
        f.rptsw[i] = 0
        f.argsw[i] = 0
    }

    // 重置参数模式
    f.pm1 = 0
    f.pm2 = 0

    // 清除控制信号和延迟数组
    for i := 0; i < 8; i++ {
        f.cons[i] = 0
        f.del[i] = 0
    }

    // 清除减法数组
    for i := 0; i < 12; i++ {
        f.sub[i] = 0
    }

    // 清除二维数组 tab
    for i := 0; i < 104; i++ {
        for j := 0; j < 14; j++ {
            f.tab[i][j] = 0
        }
    }

    // 重置其他字段
    f.arg = 0
    f.ring = 0
    f.add = false
    f.subtr = false
    f.argsetup = false
    f.gateh42 = false
    f.gatee42 = false
    f.whichrp = false
    f.px4119 = false

    // 发送更新通知
    f.update <- 1
}

// 该函数用于处理插孔的插入或移除，并更新对应的状态。它根据传入的插孔名称分配相应的通道
func ftplug(unit int, jack string, ch chan pulse) {
    // 定义一组插孔名称
    jacks := [22]string{"1i", "1o", "2i", "2o", "3i", "3o", "4i", "4o",
        "5i", "5o", "6i", "6o", "7i", "7o", "8i", "8o", "9i", "9o",
        "10i", "10o", "11i", "11o"}

    // 根据插孔名称分配通道
    switch {
    case jack == "arg", jack == "ARG":
        ftable[unit].jack[0] = ch
    case jack == "A":
        ftable[unit].jack[1] = ch
    case jack == "B":
        ftable[unit].jack[2] = ch
    case jack == "NC":
        ftable[unit].jack[3] = ch
    case jack == "C":
        ftable[unit].jack[4] = ch
    default:
        // 如果插孔名称不在预定义列表中，则查找匹配并分配通道
        for i, j := range jacks {
            if j == jack {
                ftable[unit].jack[i+5] = ch
                break
            }
        }
    }

    // 发送更新通知
    ftable[unit].update <- 1
}

// 该函数用于控制功能表的行为，接收来自通道的消息并根据消息内容更新功能表的状态
func ftctl(unit int, ch chan [2]string) {
    var digit, row, val int
    var bank, ilk rune

    // 定义操作字符串数组
    ops := [10]string{"A-2", "A-1", "A0", "A+1", "A+2", "S+2", "S+1", "S0", "S-1", "S-2"}

    // 持续监听通道中的消息
    for {
        swval := <-ch // 从通道中接收消息

        switch {
        case swval[0][:2] == "op": // 处理操作开关设置
            sw, _ := strconv.Atoi(swval[0][2:])
            for i, o := range ops {
                if o == swval[1] {
                    ftable[unit].opsw[sw-1] = i
                    break
                }
            }

        case swval[0][:2] == "cl": // 处理参数开关设置
            sw, _ := strconv.Atoi(swval[0][2:])
            switch swval[1] {
            case "0":
                ftable[unit].argsw[sw-1] = 0
            case "NC", "nc":
                ftable[unit].argsw[sw-1] = 1
            case "C", "c":
                ftable[unit].argsw[sw-1] = 2
            }

        case swval[0][:2] == "rp": // 处理重复开关设置
            sw, _ := strconv.Atoi(swval[0][2:])
            val, _ := strconv.Atoi(swval[1])
            ftable[unit].rptsw[sw-1] = val - 1

        case swval[0] == "mpm1": // 处理参数模式1设置
            switch swval[1][0] {
            case 'P', 'p':
                ftable[unit].pm1 = 0
            case 'M', 'm':
                ftable[unit].pm1 = 1
            case 'T', 't':
                ftable[unit].pm1 = 2
            }

        case swval[0] == "mpm2": // 处理参数模式2设置
            switch swval[1][0] {
            case 'P', 'p':
                ftable[unit].pm2 = 0
            case 'M', 'm':
                ftable[unit].pm2 = 1
            case 'T', 't':
                ftable[unit].pm2 = 2
            }

        case swval[0][0] == 'A' || swval[0][0] == 'B': // 处理延迟、控制信号和减法设置
            offset := 0
            fmt.Sscanf(swval[0], "%c%d%c", &bank, &digit, &ilk)
            if bank == 'B' {
                offset = 1
            }
            switch ilk {
            case 'd', 'D':
                switch swval[1] {
                case "d", "D":
                    ftable[unit].del[4*offset+digit-1] = 1
                case "o", "O":
                    ftable[unit].del[4*offset+digit-1] = 0
                }
            case 'c', 'C':
                switch swval[1] {
                case "pm1", "PM1":
                    ftable[unit].cons[4*offset+digit-1] = 10
                case "pm2", "PM2":
                    ftable[unit].cons[4*offset+digit-1] = 11
                default:
                    n, _ := strconv.Atoi(swval[1])
                    ftable[unit].cons[4*offset+digit-1] = n
                }
            case 's', 'S':
                switch swval[1] {
                case "s", "S":
                    ftable[unit].sub[6*offset+digit-5] = 1
                case "0":
                    ftable[unit].sub[6*offset+digit-5] = 0
                }
            }

        case swval[0][0] == 'R': // 处理表格数据设置
            n, _ := fmt.Sscanf(swval[0], "R%c%dL%d", &bank, &row, &digit)
            if n == 3 {
                val, _ := strconv.Atoi(swval[1])
                if bank == 'A' {
                    ftable[unit].tab[row+2][7-digit] = val
                } else {
                    ftable[unit].tab[row+2][13-digit] = val
                }
            } else {
                fmt.Sscanf(swval[0], "R%c%dS", &bank, &row)
                if swval[1] == "m" || swval[1] == "M" {
                    val = 1
                } else {
                    val = 0
                }
                if bank == 'A' {
                    ftable[unit].tab[row+2][0] = val
                } else {
                    ftable[unit].tab[row+2][13] = val
                }
            }

        case swval[0] == "ninep" || swval[0] == "Ninep": // 处理特定条件设置
            if swval[1][0] == 'C' || swval[1][0] == 'c' {
                ftable[unit].px4119 = true
            } else {
                ftable[unit].px4119 = false
            }

        default:
            fmt.Printf("Invalid function table switch %s\n", swval[0])
        }
    }
}

func addlookup(f *ft, c int) {
    var a, b int // 初始化两个整数 a 和 b，用于存储最终结果
    arg := f.arg // 获取当前参数索引

    // 处理 Ninep 条件
    if c&Ninep != 0 { // 如果控制标志包含 Ninep
        as := f.pm1 == 1 || (f.pm1 == 2 && f.tab[arg][0] == 1) // 检查 pm1 是否满足条件
        bs := f.pm2 == 1 || (f.pm2 == 2 && f.tab[arg][13] == 1) // 检查 pm2 是否满足条件

        // 根据条件设置 a 和 b 的高位（第 10 位）
        if as {
            a |= 1 << 10
        }
        if bs {
            b |= 1 << 10
        }

        // 遍历前 4 个延迟和控制信号
        for i := 0; i < 4; i++ {
            if f.del[i] == 0 { // 如果延迟为 0
                if f.cons[i] == 10 && as { // 如果控制信号为 10 且 as 为真
                    a |= 1 << (9 - uint(i)) // 设置 a 的相应位
                } else if f.cons[i] == 11 && bs { // 如果控制信号为 11 且 bs 为真
                    a |= 1 << (9 - uint(i)) // 设置 a 的相应位
                }
            }
            if f.del[i+4] == 0 { // 如果延迟为 0
                if f.cons[i+4] == 10 && as { // 如果控制信号为 10 且 as 为真
                    b |= 1 << (9 - uint(i)) // 设置 b 的相应位
                } else if f.cons[i+4] == 11 && bs { // 如果控制信号为 11 且 bs 为真
                    b |= 1 << (9 - uint(i)) // 设置 b 的相应位
                }
            }
        }

        // 遍历前 4 个控制信号，如果控制信号为 9，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if f.cons[i] == 9 {
                a |= 1 << (9 - uint(i))
            }
            if f.cons[i+4] == 9 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素为 9，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if f.tab[arg][i+1] == 9 {
                a |= 1 << (5 - uint(i))
            }
            if f.tab[arg][i+7] == 9 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Fourp 条件
    if c&Fourp != 0 { // 如果控制标志包含 Fourp
        // 遍历前 4 个控制信号，如果控制信号在 4 到 8 之间，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x >= 4 && x <= 8 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x >= 4 && x <= 8 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素在 4 到 8 之间，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x >= 4 && x <= 8 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x >= 4 && x <= 8 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Twopp 条件
    if c&Twopp != 0 { // 如果控制标志包含 Twopp
        // 遍历前 4 个控制信号，如果控制信号为 2、3 或 8，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x == 2 || x == 3 || x == 8 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x == 2 || x == 3 || x == 8 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素为 2、3 或 8，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x == 2 || x == 3 || x == 8 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x == 2 || x == 3 || x == 8 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Twop 条件
    if c&Twop != 0 { // 如果控制标志包含 Twop
        // 遍历前 4 个控制信号，如果控制信号在 6 到 8 之间，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x > 5 && x < 9 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x > 5 && x < 9 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素在 6 到 8 之间，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x > 5 && x < 9 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x > 5 && x < 9 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Onep 条件
    if c&Onep != 0 { // 如果控制标志包含 Onep
        // 遍历前 4 个控制信号，如果控制信号小于 9 且为奇数，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x < 9 && x%2 == 1 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x < 9 && x%2 == 1 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素小于 9 且为奇数，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x < 9 && x%2 == 1 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x < 9 && x%2 == 1 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 如果 a 不为 0 且 jack[1] 通道不为空，则发送 a 的值并通过 resp 通道等待响应
    if a != 0 && f.jack[1] != nil {
        f.jack[1] <- pulse{a, f.resp}
        <-f.resp
    }

    // 如果 b 不为 0 且 jack[2] 通道不为空，则发送 b 的值并通过 resp 通道等待响应
    if b != 0 && f.jack[2] != nil {
        f.jack[2] <- pulse{b, f.resp}
        <-f.resp
    }
}

func subtrlookup(f *ft, c int) {
    var a, b int // 初始化两个整数 a 和 b，用于存储最终结果
    arg := f.arg // 获取当前参数索引

    // 处理 Ninep 条件
    if c&Ninep != 0 { // 如果控制标志包含 Ninep
        as := f.pm1 == 0 || (f.pm1 == 2 && f.tab[arg][0] == 0) // 检查 pm1 是否满足条件
        bs := f.pm2 == 0 || (f.pm2 == 2 && f.tab[arg][13] == 0) // 检查 pm2 是否满足条件

        // 根据条件设置 a 和 b 的高位（第 10 位）
        if as {
            a |= 1 << 10
        }
        if bs {
            b |= 1 << 10
        }

        // 遍历前 4 个延迟和控制信号
        for i := 0; i < 4; i++ {
            if f.del[i] == 0 { // 如果延迟为 0
                if f.cons[i] == 10 && as { // 如果控制信号为 10 且 as 为真
                    a |= 1 << (9 - uint(i)) // 设置 a 的相应位
                } else if f.cons[i] == 11 && bs { // 如果控制信号为 11 且 bs 为真
                    a |= 1 << (9 - uint(i)) // 设置 a 的相应位
                }
            }
            if f.del[i+4] == 0 { // 如果延迟为 0
                if f.cons[i+4] == 10 && as { // 如果控制信号为 10 且 as 为真
                    b |= 1 << (9 - uint(i)) // 设置 b 的相应位
                } else if f.cons[i+4] == 11 && bs { // 如果控制信号为 11 且 bs 为真
                    b |= 1 << (9 - uint(i)) // 设置 b 的相应位
                }
            }
        }
    }

    // 处理 Fourp 条件
    if c&Fourp != 0 { // 如果控制标志包含 Fourp
        // 遍历前 4 个控制信号，如果控制信号小于 6，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x < 6 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x < 6 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素小于 6，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x < 6 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x < 6 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Twopp 条件
    if c&Twopp != 0 { // 如果控制标志包含 Twopp
        // 遍历前 4 个控制信号，如果控制信号小于 2，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x < 2 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x < 2 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素小于 2，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x < 2 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x < 2 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Twop 条件
    if c&Twop != 0 { // 如果控制标志包含 Twop
        // 遍历前 4 个控制信号，如果控制信号等于 6 或 7 或者小于 4，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x == 6 || x == 7 || x < 4 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x == 6 || x == 7 || x < 4 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素等于 6 或 7 或者小于 4，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x == 6 || x == 7 || x < 4 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x == 6 || x == 7 || x < 4 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Onep 条件
    if c&Onep != 0 { // 如果控制标志包含 Onep
        // 遍历前 4 个控制信号，如果控制信号小于 10 且为偶数，则设置 a 和 b 的相应位
        for i := 0; i < 4; i++ {
            if x := f.cons[i]; x < 10 && x%2 == 0 {
                a |= 1 << (9 - uint(i))
            }
            if x := f.cons[i+4]; x < 10 && x%2 == 0 {
                b |= 1 << (9 - uint(i))
            }
        }

        // 遍历表格中的前 6 个元素，如果元素小于 10 且为偶数，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if x := f.tab[arg][i+1]; x < 10 && x%2 == 0 {
                a |= 1 << (5 - uint(i))
            }
            if x := f.tab[arg][i+7]; x < 10 && x%2 == 0 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 处理 Onepp 条件
    if c&Onepp != 0 { // 如果控制标志包含 Onepp
        // 遍历前 6 个减法元素，如果元素等于 1，则设置 a 和 b 的相应位
        for i := 0; i < 6; i++ {
            if f.sub[i] == 1 {
                a |= 1 << (5 - uint(i))
            }
            if f.sub[i+6] == 1 {
                b |= 1 << (5 - uint(i))
            }
        }
    }

    // 如果 a 不为 0 且 jack[1] 通道不为空，则发送 a 的值并通过 resp 通道等待响应
    if a != 0 && f.jack[1] != nil {
        f.jack[1] <- pulse{a, f.resp}
        <-f.resp
    }

    // 如果 b 不为 0 且 jack[2] 通道不为空，则发送 b 的值并通过 resp 通道等待响应
    if b != 0 && f.jack[2] != nil {
        f.jack[2] <- pulse{b, f.resp}
        <-f.resp
    }
}

func ftunit(unit int, cyctrunk chan pulse) {
    var prog int // 用于存储程序计数器或状态变量

    f := &ftable[unit] // 获取指定单元的功能表指针
    f.update = make(chan int) // 初始化 update 通道
    go ftunit2(f) // 启动辅助协程 ftunit2 来处理某些后台任务
    f.resp = make(chan int) // 初始化响应通道

    for {
        p := <-cyctrunk // 从 cyctrunk 通道接收脉冲信号

        if f.px4119 { // 如果 px4119 标志为真
            if p.val&Cpp != 0 { // 如果脉冲值包含 Cpp 标志
                p.val |= Ninep // 设置 Ninep 标志
            } else {
                p.val &= ^Ninep // 清除 Ninep 标志
            }
        }

        c := p.val // 获取脉冲信号的值

        if f.gatee42 { // 如果 gatee42 标志为真
            sw := f.opsw[prog] // 获取当前操作开关的状态
            if c&Onep != 0 && (sw == 1 || sw == 3 || sw == 6 || sw == 8) {
                f.arg++ // 根据条件增加参数索引
            }
            if c&Twop != 0 && (sw == 2 || sw == 3 || sw == 6 || sw == 7) {
                f.arg++ // 根据条件增加参数索引
            }
            if c&Fourp != 0 && (sw == 4 || sw == 5) {
                f.arg++ // 根据条件增加参数索引
            }
        }

        if f.add { // 如果 add 标志为真
            if f.arg >= 0 && f.arg < 104 { // 检查参数索引是否有效
                addlookup(f, c) // 调用 addlookup 函数
            } else {
                fmt.Println("Invalid function table argument", f.arg) // 打印错误信息
            }
        }

        if f.subtr { // 如果 subtr 标志为真
            if f.arg >= 0 && f.arg < 104 { // 检查参数索引是否有效
                subtrlookup(f, c) // 调用 subtrlookup 函数
            } else {
                fmt.Println("Invalid function table argument", f.arg) // 打印错误信息
            }
        }

        if c&Cpp != 0 { // 如果脉冲值包含 Cpp 标志
            switch f.ring { // 根据 ring 状态进行不同阶段的操作
            case 0: // Stage -3
                for prog = 0; prog < 11 && !f.inff2[prog]; prog++ {
                    // 查找第一个 inff2 为真的位置
                }
                if prog >= 11 {
                    break // 如果没有找到，退出循环
                }
                switch f.argsw[prog] { // 根据 argsw 的值进行不同的操作
                case 1:
                    if f.jack[3] != nil {
                        f.jack[3] <- pulse{1, f.resp} // 发送脉冲信号
                        <-f.resp // 等待响应
                    }
                case 2:
                    if f.jack[4] != nil {
                        f.jack[4] <- pulse{1, f.resp} // 发送脉冲信号
                        <-f.resp // 等待响应
                    }
                }
                f.ring++ // 进入下一个阶段（Stage -2）
                f.gateh42 = true

            case 1:
                f.ring++ // 进入下一个阶段（Stage -1）
                f.gateh42 = false
                f.gatee42 = true

            case 2:
                f.ring++ // 进入下一个阶段（Stage 0）
                f.gatee42 = false
                /*
                	if f.opsw[prog] < 5 {
                		f.add = true
                	} else {
                		f.subtr = true
                	}
                */

            case 3: // Stage 0
                f.ring++ // 进入下一个阶段（Stage 1）
                if f.opsw[prog] < 5 {
                    f.add = true
                } else {
                    f.subtr = true
                }

            default: // Stages 1-9
                if f.rptsw[prog] == f.ring-4 {
                    if f.jack[prog*2+6] != nil {
                        f.jack[prog*2+6] <- pulse{1, f.resp} // 发送脉冲信号
                        <-f.resp // 等待响应
                    }
                    f.arg = 0
                    f.add = false
                    f.subtr = false
                    f.inff2[prog] = false
                    f.argsetup = false
                    f.ring = 0
                } else {
                    f.ring++
                }
            }
        }

        if c&Ccg != 0 { // 如果脉冲值包含 Ccg 标志
            f.whichrp = false
        }

        if c&Rp != 0 { // 如果脉冲值包含 Rp 标志
            if f.whichrp {
                for i, _ := range f.inff1 {
                    if f.inff1[i] {
                        f.inff1[i] = false
                        f.inff2[i] = true
                    }
                }
                f.whichrp = false
            } else {
                f.whichrp = true
            }
        }

        if f.ring == 2 && c&Onepp != 0 { // 如果 ring 为 2 且脉冲值包含 Onepp 标志
            f.argsetup = true
        }

        if p.resp != nil { // 如果有响应通道
            p.resp <- 1 // 发送响应
        }
    }
}

func ftunit2(f *ft) {
    var p pulse // 定义一个脉冲变量

    for {
        select {
        case <-f.update:
            // 处理 update 通道的消息（当前代码中没有具体操作）
            break

        case p = <-f.jack[5]:
            // 当从 f.jack[5] 接收到脉冲时，设置 f.inff1[0] 为 true
            f.inff1[0] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[7]:
            // 当从 f.jack[7] 接收到脉冲时，设置 f.inff1[1] 为 true
            f.inff1[1] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[9]:
            // 当从 f.jack[9] 接收到脉冲时，设置 f.inff1[2] 为 true
            f.inff1[2] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[11]:
            // 当从 f.jack[11] 接收到脉冲时，设置 f.inff1[3] 为 true
            f.inff1[3] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[13]:
            // 当从 f.jack[13] 接收到脉冲时，设置 f.inff1[4] 为 true
            f.inff1[4] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[15]:
            // 当从 f.jack[15] 接收到脉冲时，设置 f.inff1[5] 为 true
            f.inff1[5] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[17]:
            // 当从 f.jack[17] 接收到脉冲时，设置 f.inff1[6] 为 true
            f.inff1[6] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[19]:
            // 当从 f.jack[19] 接收到脉冲时，设置 f.inff1[7] 为 true
            f.inff1[7] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[21]:
            // 当从 f.jack[21] 接收到脉冲时，设置 f.inff1[8] 为 true
            f.inff1[8] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[23]:
            // 当从 f.jack[23] 接收到脉冲时，设置 f.inff1[9] 为 true
            f.inff1[9] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case p = <-f.jack[25]:
            // 当从 f.jack[25] 接收到脉冲时，设置 f.inff1[10] 为 true
            f.inff1[10] = true
            if p.resp != nil {
                p.resp <- 1 // 如果有响应通道，则发送响应
            }

        case arg := <-f.jack[0]:
            // 当从 f.jack[0] 接收到脉冲时，检查 gateh42 标志并更新参数索引
            if f.gateh42 {
                if arg.val&0x01 != 0 {
                    f.arg++ // 如果最低位为 1，则增加参数索引
                }
                if arg.val&0x02 != 0 {
                    f.arg += 10 // 如果次低位为 1，则增加参数索引 10
                }
            }
            if arg.resp != nil {
                arg.resp <- 1 // 如果有响应通道，则发送响应
            }
        }
    }
}
